<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en-us"><head><script charset="utf-8" src="Google%20Java%E7%BC%96%E7%A8%8B%E9%A3%8E%E6%A0%BC%E6%8C%87%E5%8D%97_files/shares.js"></script>
    <meta http-equiv="content-type" content="text/html; charset=UTF-8">
    <title>Google Java编程风格指南</title>
    <meta name="author" content="Hawstein">
    <link href="http://hawstein.com/atom.xml" rel="alternate" title="Hawstein's Blog" type="application/atom+xml">

    <!-- Homepage CSS -->
    <link rel="stylesheet" href="Google%20Java%E7%BC%96%E7%A8%8B%E9%A3%8E%E6%A0%BC%E6%8C%87%E5%8D%97_files/bootstrap.css" type="text/css" media="screen" charset="utf-8">
    <link rel="stylesheet" href="Google%20Java%E7%BC%96%E7%A8%8B%E9%A3%8E%E6%A0%BC%E6%8C%87%E5%8D%97_files/bootstrap-responsive.css" type="text/css" media="screen" charset="utf-8">
    <link rel="stylesheet" href="Google%20Java%E7%BC%96%E7%A8%8B%E9%A3%8E%E6%A0%BC%E6%8C%87%E5%8D%97_files/app.css" type="text/css" media="screen" charset="utf-8">

    <!-- Le HTML5 shim, for IE6-8 support of HTML5 elements -->
    <!--[if lt IE 9]>
	<script src="http://html5shim.googlecode.com/svn/trunk/html5.js"></script>
	<![endif]-->

    <!-- syntax highlighting CSS -->
    <link rel="stylesheet" href="Google%20Java%E7%BC%96%E7%A8%8B%E9%A3%8E%E6%A0%BC%E6%8C%87%E5%8D%97_files/syntax.css" type="text/css" media="screen" charset="utf-8">

    <link rel="shortcut icon" href="http://hawstein.com/assets/ico/favicon.ico">
      <!-- Fonts -->
      <link href="Google%20Java%E7%BC%96%E7%A8%8B%E9%A3%8E%E6%A0%BC%E6%8C%87%E5%8D%97_files/css.css" rel="stylesheet" type="text/css">
      <script src="Google%20Java%E7%BC%96%E7%A8%8B%E9%A3%8E%E6%A0%BC%E6%8C%87%E5%8D%97_files/ga.js" async="" type="text/javascript"></script><script src="Google%20Java%E7%BC%96%E7%A8%8B%E9%A3%8E%E6%A0%BC%E6%8C%87%E5%8D%97_files/embed.js" async="" type="text/javascript"></script></head>

      <body><link type="text/css" rel="stylesheet" href="Google%20Java%E7%BC%96%E7%A8%8B%E9%A3%8E%E6%A0%BC%E6%8C%87%E5%8D%97_files/jiathis_counter.css"><script charset="utf-8" src="Google%20Java%E7%BC%96%E7%A8%8B%E9%A3%8E%E6%A0%BC%E6%8C%87%E5%8D%97_files/jiathis.js"></script><link type="text/css" rel="stylesheet" href="Google%20Java%E7%BC%96%E7%A8%8B%E9%A3%8E%E6%A0%BC%E6%8C%87%E5%8D%97_files/jiathis_share.css"><iframe style="position: fixed; display: none; opacity: 0;" frameborder="0"></iframe><div style="position: absolute; z-index: 1000000000; display: none; top: 50%; left: 50%; overflow: auto;" class="jiathis_style"></div><div style="position: absolute; z-index: 1000000000; display: none; overflow: auto;" class="jiathis_style"></div><iframe src="Google%20Java%E7%BC%96%E7%A8%8B%E9%A3%8E%E6%A0%BC%E6%8C%87%E5%8D%97_files/jiathis_utility.html" style="display: none;" frameborder="0"></iframe>
	<div class="navbar navbar-fixed-top">
  <div class="navbar-inner">
    <div class="container">
      <a class="brand" href="http://hawstein.com/">Hawstein's Blog</a>
	<ul class="nav">
	  <li class=""><a href="http://hawstein.com/">Home</a></li>
	  <li><a href="http://hawstein.com/archive.html">Archive</a></li>
	  <li><a href="http://hawstein.com/categories.html">Categories</a></li>
	  <li><a href="http://hawstein.com/sitemap.html">Sitemap</a></li>
	  <li><a href="http://hawstein.com/about.html">About</a></li>
	</ul>
	<ul class="nav pull-right">
	  <li><a href="http://hawstein.com/atom.xml">Subscribe</a></li>
	</ul>
    </div>
  </div>
</div>

	<div class="container">
	  <div id="post">
<h1>
  <a href="http://hawstein.com/posts/google-java-style.html">Google Java编程风格指南</a>
</h1>
<div class="authoring">
  January 20, 2014
</div>
<div style="line-height:180%;">
  作者：Hawstein<br>
  出处：<a href="http://hawstein.com/posts/google-java-style.html">http://hawstein.com/posts/google-java-style.html</a><br>
  声明：本文采用以下协议进行授权： <a href="http://creativecommons.org/licenses/by-nc-nd/3.0/deed.zh">自由转载-非商用-非衍生-保持署名|Creative Commons BY-NC-ND 3.0</a> ，转载请注明作者及出处。<br><br>
</div>

<h2>目录</h2>

<ol>
<li><a href="#Intro">前言</a></li>
<li><a href="#SFBasic">源文件基础</a></li>
<li><a href="#SFStruct">源文件结构</a></li>
<li><a href="#Format">格式</a></li>
<li><a href="#Naming">命名约定</a></li>
<li><a href="#Practice">编程实践</a></li>
<li><a href="#Javadoc">Javadoc</a></li>
<li><a href="#End">后记</a></li>
</ol>


<h2><a id="Intro">前言</a></h2>

<p>这份文档是Google Java编程风格规范的完整定义。当且仅当一个Java源文件符合此文档中的规则，
我们才认为它符合Google的Java编程风格。</p>

<p>与其它的编程风格指南一样，这里所讨论的不仅仅是编码格式美不美观的问题，
同时也讨论一些约定及编码标准。然而，这份文档主要侧重于我们所普遍遵循的规则，
对于那些不是明确强制要求的，我们尽量避免提供意见。</p>

<h3>1.1 术语说明</h3>

<p>在本文档中，除非另有说明：</p>

<ol>
<li>术语class可表示一个普通类，枚举类，接口或是annotation类型(<code>@interface</code>)</li>
<li>术语comment只用来指代实现的注释(implementation comments)，我们不使用“documentation comments”一词，而是用Javadoc。</li>
</ol>


<p>其他的术语说明会偶尔在后面的文档出现。</p>

<h3>1.2 指南说明</h3>

<p>本文档中的示例代码并不作为规范。也就是说，虽然示例代码是遵循Google编程风格，但并不意味着这是展现这些代码的唯一方式。
示例中的格式选择不应该被强制定为规则。</p>

<h2><a id="SFBasic">源文件基础</a></h2>

<h3>2.1 文件名</h3>

<p>源文件以其最顶层的类名来命名，大小写敏感，文件扩展名为<code>.java</code>。</p>

<h3>2.2 文件编码：UTF-8</h3>

<p>源文件编码格式为UTF-8。</p>

<h3>2.3 特殊字符</h3>

<h4>2.3.1 空白字符</h4>

<p>除了行结束符序列，ASCII水平空格字符(0x20，即空格)是源文件中唯一允许出现的空白字符，这意味着：</p>

<ol>
<li>所有其它字符串中的空白字符都要进行转义。</li>
<li>制表符不用于缩进。</li>
</ol>


<h4>2.3.2 特殊转义序列</h4>

<p>对于具有特殊<a href="http://zh.wikipedia.org/wiki/%E8%BD%AC%E4%B9%89%E5%BA%8F%E5%88%97">转义序列</a>的任何字符(\b, \t, \n, \f, \r, \“, \‘及\)，我们使用它的转义序列，而不是相应的八进制(比如<code>\012</code>)或Unicode(比如<code>\u000a</code>)转义。</p>

<h4>2.3.3 非ASCII字符</h4>

<p>对于剩余的非ASCII字符，是使用实际的Unicode字符(比如∞)，还是使用等价的Unicode转义符(比如\u221e)，取决于哪个能让代码更易于阅读和理解。</p>

<blockquote><blockquote><p>Tip: 在使用Unicode转义符或是一些实际的Unicode字符时，建议做些注释给出解释，这有助于别人阅读和理解。</p></blockquote></blockquote>

<p>例如：</p>

<pre><code>String unitAbbrev = "μs";                                 | 赞，即使没有注释也非常清晰
String unitAbbrev = "\u03bcs"; // "μs"                    | 允许，但没有理由要这样做
String unitAbbrev = "\u03bcs"; // Greek letter mu, "s"    | 允许，但这样做显得笨拙还容易出错
String unitAbbrev = "\u03bcs";                            | 很糟，读者根本看不出这是什么
return '\ufeff' + content; // byte order mark             | Good，对于非打印字符，使用转义，并在必要时写上注释
</code></pre>

<blockquote><blockquote><p>Tip: 永远不要由于害怕某些程序可能无法正确处理非ASCII字符而让你的代码可读性变差。当程序无法正确处理非ASCII字符时，它自然无法正确运行，
你就会去fix这些问题的了。(言下之意就是大胆去用非ASCII字符，如果真的有需要的话)</p></blockquote></blockquote>

<h2><a id="SFStruct">源文件结构</a></h2>

<p>一个源文件包含(按顺序地)：</p>

<ol>
<li>许可证或版权信息(如有需要)</li>
<li>package语句</li>
<li>import语句</li>
<li>一个顶级类(<strong>只有一个</strong>)</li>
</ol>


<p>以上每个部分之间用一个空行隔开。</p>

<h3>3.1 许可证或版权信息</h3>

<p>如果一个文件包含许可证或版权信息，那么它应当被放在文件最前面。</p>

<h3>3.2 package语句</h3>

<p>package语句不换行，列限制(4.4节)并不适用于package语句。(即package语句写在一行里)</p>

<h3>3.3 import语句</h3>

<h4>3.3.1 import不要使用通配符</h4>

<p>即，不要出现类似这样的import语句：<code>import java.util.*;</code></p>

<h4>3.3.2 不要换行</h4>

<p>import语句不换行，列限制(4.4节)并不适用于import语句。(每个import语句独立成行)</p>

<h4>3.3.3 顺序和间距</h4>

<p>import语句可分为以下几组，按照这个顺序，每组由一个空行分隔：</p>

<ol>
<li>所有的静态导入独立成组</li>
<li><code>com.google</code> imports(仅当这个源文件是在<code>com.google</code>包下)</li>
<li>第三方的包。每个顶级包为一组，字典序。例如：android, com, junit, org, sun</li>
<li><code>java</code> imports</li>
<li><code>javax</code> imports</li>
</ol>


<p>组内不空行，按字典序排列。</p>

<h3>3.4 类声明</h3>

<h4>3.4.1 只有一个顶级类声明</h4>

<p>每个顶级类都在一个与它同名的源文件中(当然，还包含<code>.java</code>后缀)。</p>

<p>例外：<code>package-info.java</code>，该文件中可没有<code>package-info</code>类。</p>

<h4>3.4.2 类成员顺序</h4>

<p>类的成员顺序对易学性有很大的影响，但这也不存在唯一的通用法则。不同的类对成员的排序可能是不同的。
最重要的一点，每个类应该以某种逻辑去排序它的成员，维护者应该要能解释这种排序逻辑。比如，
新的方法不能总是习惯性地添加到类的结尾，因为这样就是按时间顺序而非某种逻辑来排序的。</p>

<h5>3.4.2.1 重载：永不分离</h5>

<p>当一个类有多个构造函数，或是多个同名方法，这些函数/方法应该按顺序出现在一起，中间不要放进其它函数/方法。</p>

<h2><a id="Format">格式</a></h2>

<p><strong>术语说明</strong>：块状结构(block-like construct)指的是一个类，方法或构造函数的主体。需要注意的是，数组初始化中的初始值可被选择性地视为块状结构(4.8.3.1节)。</p>

<h3>4.1 大括号</h3>

<h4>4.1.1 使用大括号(即使是可选的)</h4>

<p>大括号与<code>if, else, for, do, while</code>语句一起使用，即使只有一条语句(或是空)，也应该把大括号写上。</p>

<h4>4.1.2 非空块：K &amp; R 风格</h4>

<p>对于非空块和块状结构，大括号遵循Kernighan和Ritchie风格
(<a href="http://www.codinghorror.com/blog/2012/07/new-programming-jargon.html">Egyptian brackets</a>):</p>

<ul>
<li>左大括号前不换行</li>
<li>左大括号后换行</li>
<li>右大括号前换行</li>
<li>如果右大括号是一个语句、函数体或类的终止，则右大括号后换行; 否则不换行。例如，如果右大括号后面是else或逗号，则不换行。</li>
</ul>


<p>示例：</p>

<div class="highlight"><pre><code class="java"><span class="k">return</span> <span class="k">new</span> <span class="nf">MyClass</span><span class="o">()</span> <span class="o">{</span>
  <span class="nd">@Override</span> <span class="kd">public</span> <span class="kt">void</span> <span class="n">method</span><span class="o">()</span> <span class="o">{</span>
    <span class="k">if</span> <span class="o">(</span><span class="n">condition</span><span class="o">())</span> <span class="o">{</span>
      <span class="k">try</span> <span class="o">{</span>
        <span class="n">something</span><span class="o">();</span>
      <span class="o">}</span> <span class="k">catch</span> <span class="o">(</span><span class="n">ProblemException</span> <span class="n">e</span><span class="o">)</span> <span class="o">{</span>
        <span class="n">recover</span><span class="o">();</span>
      <span class="o">}</span>
    <span class="o">}</span>
  <span class="o">}</span>
<span class="o">};</span>
</code></pre></div>


<p>4.8.1节给出了enum类的一些例外。</p>

<h4>4.1.3 空块：可以用简洁版本</h4>

<p>一个空的块状结构里什么也不包含，大括号可以简洁地写成<code>{}</code>，不需要换行。例外：如果它是一个多块语句的一部分(if/else 或 try/catch/finally)
，即使大括号内没内容，右大括号也要换行。</p>

<p>示例：</p>

<div class="highlight"><pre><code class="java"><span class="kt">void</span> <span class="nf">doNothing</span><span class="o">()</span> <span class="o">{}</span>
</code></pre></div>


<h3>4.2 块缩进：2个空格</h3>

<p>每当开始一个新的块，缩进增加2个空格，当块结束时，缩进返回先前的缩进级别。缩进级别适用于代码和注释。(见4.1.2节中的代码示例)</p>

<h3>4.3 一行一个语句</h3>

<p>每个语句后要换行。</p>

<h3>4.4 列限制：80或100</h3>

<p>一个项目可以选择一行80个字符或100个字符的列限制，除了下述例外，任何一行如果超过这个字符数限制，必须自动换行。</p>

<p>例外：</p>

<ol>
<li>不可能满足列限制的行(例如，Javadoc中的一个长URL，或是一个长的JSNI方法参考)。</li>
<li><code>package</code>和<code>import</code>语句(见3.2节和3.3节)。</li>
<li>注释中那些可能被剪切并粘贴到shell中的命令行。</li>
</ol>


<h3>4.5 自动换行</h3>

<p><strong>术语说明</strong>：一般情况下，一行长代码为了避免超出列限制(80或100个字符)而被分为多行，我们称之为自动换行(line-wrapping)。</p>

<p>我们并没有全面，确定性的准则来决定在每一种情况下如何自动换行。很多时候，对于同一段代码会有好几种有效的自动换行方式。</p>

<blockquote><blockquote><p>Tip: 提取方法或局部变量可以在不换行的情况下解决代码过长的问题(是合理缩短命名长度吧)</p></blockquote></blockquote>

<h4>4.5.1 从哪里断开</h4>

<p>自动换行的基本准则是：更倾向于在更高的语法级别处断开。</p>

<ol>
<li>如果在<code>非赋值运算符</code>处断开，那么在该符号前断开(比如+，它将位于下一行)。注意：这一点与Google其它语言的编程风格不同(如C++和JavaScript)。
这条规则也适用于以下“类运算符”符号：点分隔符(.)，类型界限中的&amp;（<code>&lt;T extends Foo &amp; Bar&gt;</code>)，catch块中的管道符号(<code>catch (FooException | BarException e</code>)</li>
<li>如果在<code>赋值运算符</code>处断开，通常的做法是在该符号后断开(比如=，它与前面的内容留在同一行)。这条规则也适用于<code>foreach</code>语句中的分号。</li>
<li>方法名或构造函数名与左括号留在同一行。</li>
<li>逗号(,)与其前面的内容留在同一行。</li>
</ol>


<h4>4.5.2 自动换行时缩进至少+4个空格</h4>

<p>自动换行时，第一行后的每一行至少比第一行多缩进4个空格(注意：制表符不用于缩进。见2.3.1节)。</p>

<p>当存在连续自动换行时，缩进可能会多缩进不只4个空格(语法元素存在多级时)。一般而言，两个连续行使用相同的缩进当且仅当它们开始于同级语法元素。</p>

<p>第4.6.3水平对齐一节中指出，不鼓励使用可变数目的空格来对齐前面行的符号。</p>

<h3>4.6 空白</h3>

<h4>4.6.1 垂直空白</h4>

<p>以下情况需要使用一个空行：</p>

<ol>
<li>类内连续的成员之间：字段，构造函数，方法，嵌套类，静态初始化块，实例初始化块。

<ul>
<li><strong>例外</strong>：两个连续字段之间的空行是可选的，用于字段的空行主要用来对字段进行逻辑分组。</li>
</ul>
</li>
<li>在函数体内，语句的逻辑分组间使用空行。</li>
<li>类内的第一个成员前或最后一个成员后的空行是可选的(既不鼓励也不反对这样做，视个人喜好而定)。</li>
<li>要满足本文档中其他节的空行要求(比如3.3节：import语句)</li>
</ol>


<p>多个连续的空行是允许的，但没有必要这样做(我们也不鼓励这样做)。</p>

<h4>4.6.2 水平空白</h4>

<p>除了语言需求和其它规则，并且除了文字，注释和Javadoc用到单个空格，单个ASCII空格也出现在以下几个地方：</p>

<ol>
<li>分隔任何保留字与紧随其后的左括号(<code>(</code>)(如<code>if, for catch</code>等)。</li>
<li>分隔任何保留字与其前面的右大括号(<code>}</code>)(如<code>else, catch</code>)。</li>
<li>在任何左大括号前(<code>{</code>)，两个例外：

<ul>
<li><code>@SomeAnnotation({a, b})</code>(不使用空格)。</li>
<li><code>String[][] x = foo;</code>(大括号间没有空格，见下面的Note)。</li>
</ul>
</li>
<li>在任何二元或三元运算符的两侧。这也适用于以下“类运算符”符号：

<ul>
<li>类型界限中的&amp;(<code>&lt;T extends Foo &amp; Bar&gt;</code>)。</li>
<li>catch块中的管道符号(<code>catch (FooException | BarException e</code>)。</li>
<li><code>foreach</code>语句中的分号。</li>
</ul>
</li>
<li>在<code>, : ;</code>及右括号(<code>)</code>)后</li>
<li>如果在一条语句后做注释，则双斜杠(//)两边都要空格。这里可以允许多个空格，但没有必要。</li>
<li>类型和变量之间：List<string> list。</string></li>
<li>数组初始化中，大括号内的空格是可选的，即<code>new int[] {5, 6}</code>和<code>new int[] { 5, 6 }</code>都是可以的。</li>
</ol>


<blockquote><blockquote><p>Note：这个规则并不要求或禁止一行的开关或结尾需要额外的空格，只对内部空格做要求。</p></blockquote></blockquote>

<h4>4.6.3 水平对齐：不做要求</h4>

<p><strong>术语说明</strong>：水平对齐指的是通过增加可变数量的空格来使某一行的字符与上一行的相应字符对齐。</p>

<p>这是允许的(而且在不少地方可以看到这样的代码)，但Google编程风格对此不做要求。即使对于已经使用水平对齐的代码，我们也不需要去保持这种风格。</p>

<p>以下示例先展示未对齐的代码，然后是对齐的代码：</p>

<div class="highlight"><pre><code class="java"><span class="kd">private</span> <span class="kt">int</span> <span class="n">x</span><span class="o">;</span> <span class="c1">// this is fine</span>
<span class="kd">private</span> <span class="n">Color</span> <span class="n">color</span><span class="o">;</span> <span class="c1">// this too</span>

<span class="kd">private</span> <span class="kt">int</span>   <span class="n">x</span><span class="o">;</span>      <span class="c1">// permitted, but future edits</span>
<span class="kd">private</span> <span class="n">Color</span> <span class="n">color</span><span class="o">;</span>  <span class="c1">// may leave it unaligned</span>
</code></pre></div>


<blockquote><blockquote><p>Tip：对齐可增加代码可读性，但它为日后的维护带来问题。考虑未来某个时候，我们需要修改一堆对齐的代码中的一行。
这可能导致原本很漂亮的对齐代码变得错位。很可能它会提示你调整周围代码的空白来使这一堆代码重新水平对齐(比如程序员想保持这种水平对齐的风格)，
这就会让你做许多的无用功，增加了reviewer的工作并且可能导致更多的合并冲突。</p></blockquote></blockquote>

<h3>4.7 用小括号来限定组：推荐</h3>

<p>除非作者和reviewer都认为去掉小括号也不会使代码被误解，或是去掉小括号能让代码更易于阅读，否则我们不应该去掉小括号。
我们没有理由假设读者能记住整个Java运算符优先级表。</p>

<h3>4.8 具体结构</h3>

<h4>4.8.1 枚举类</h4>

<p>枚举常量间用逗号隔开，换行可选。</p>

<p>没有方法和文档的枚举类可写成数组初始化的格式：</p>

<div class="highlight"><pre><code class="java"><span class="kd">private</span> <span class="kd">enum</span> <span class="n">Suit</span> <span class="o">{</span> <span class="n">CLUBS</span><span class="o">,</span> <span class="n">HEARTS</span><span class="o">,</span> <span class="n">SPADES</span><span class="o">,</span> <span class="n">DIAMONDS</span> <span class="o">}</span>
</code></pre></div>


<p>由于枚举类也是一个类，因此所有适用于其它类的格式规则也适用于枚举类。</p>

<h4>4.8.2 变量声明</h4>

<h5>4.8.2.1 每次只声明一个变量</h5>

<p>不要使用组合声明，比如<code>int a, b;</code>。</p>

<h5>4.8.2.2 需要时才声明，并尽快进行初始化</h5>

<p>不要在一个代码块的开头把局部变量一次性都声明了(这是c语言的做法)，而是在第一次需要使用它时才声明。
局部变量在声明时最好就进行初始化，或者声明后尽快进行初始化。</p>

<h4>4.8.3 数组</h4>

<h5>4.8.3.1 数组初始化：可写成块状结构</h5>

<p>数组初始化可以写成块状结构，比如，下面的写法都是OK的：</p>

<div class="highlight"><pre><code class="java"><span class="k">new</span> <span class="kt">int</span><span class="o">[]</span> <span class="o">{</span>
  <span class="mi">0</span><span class="o">,</span> <span class="mi">1</span><span class="o">,</span> <span class="mi">2</span><span class="o">,</span> <span class="mi">3</span> 
<span class="o">}</span>

<span class="k">new</span> <span class="kt">int</span><span class="o">[]</span> <span class="o">{</span>
  <span class="mi">0</span><span class="o">,</span>
  <span class="mi">1</span><span class="o">,</span>
  <span class="mi">2</span><span class="o">,</span>
  <span class="mi">3</span>
<span class="o">}</span>

<span class="k">new</span> <span class="kt">int</span><span class="o">[]</span> <span class="o">{</span>
  <span class="mi">0</span><span class="o">,</span> <span class="mi">1</span><span class="o">,</span>
  <span class="mi">2</span><span class="o">,</span> <span class="mi">3</span>
<span class="o">}</span>

<span class="k">new</span> <span class="kt">int</span><span class="o">[]</span>
    <span class="o">{</span><span class="mi">0</span><span class="o">,</span> <span class="mi">1</span><span class="o">,</span> <span class="mi">2</span><span class="o">,</span> <span class="mi">3</span><span class="o">}</span>
</code></pre></div>


<h5>4.8.3.2 非C风格的数组声明</h5>

<p>中括号是类型的一部分：<code>String[] args</code>， 而非<code>String args[]</code>。</p>

<h4>4.8.4 switch语句</h4>

<p><strong>术语说明</strong>：switch块的大括号内是一个或多个语句组。每个语句组包含一个或多个switch标签(<code>case FOO:</code>或<code>default:</code>)，后面跟着一条或多条语句。</p>

<h5>4.8.4.1 缩进</h5>

<p>与其它块状结构一致，switch块中的内容缩进为2个空格。</p>

<p>每个switch标签后新起一行，再缩进2个空格，写下一条或多条语句。</p>

<h5>4.8.4.2 Fall-through：注释</h5>

<p>在一个switch块内，每个语句组要么通过<code>break, continue, return</code>或抛出异常来终止，要么通过一条注释来说明程序将继续执行到下一个语句组，
任何能表达这个意思的注释都是OK的(典型的是用<code>// fall through</code>)。这个特殊的注释并不需要在最后一个语句组(一般是<code>default</code>)中出现。示例：</p>

<div class="highlight"><pre><code class="java"><span class="k">switch</span> <span class="o">(</span><span class="n">input</span><span class="o">)</span> <span class="o">{</span>
  <span class="k">case</span> <span class="mi">1</span><span class="o">:</span>
  <span class="k">case</span> <span class="mi">2</span><span class="o">:</span>
    <span class="n">prepareOneOrTwo</span><span class="o">();</span>
    <span class="c1">// fall through</span>
  <span class="k">case</span> <span class="mi">3</span><span class="o">:</span>
    <span class="n">handleOneTwoOrThree</span><span class="o">();</span>
    <span class="k">break</span><span class="o">;</span>
  <span class="k">default</span><span class="o">:</span>
    <span class="n">handleLargeNumber</span><span class="o">(</span><span class="n">input</span><span class="o">);</span>
<span class="o">}</span>
</code></pre></div>


<h5>4.8.4.3 default的情况要写出来</h5>

<p>每个switch语句都包含一个<code>default</code>语句组，即使它什么代码也不包含。</p>

<h4>4.8.5 注解(Annotations)</h4>

<p>注解紧跟在文档块后面，应用于类、方法和构造函数，一个注解独占一行。这些换行不属于自动换行(第4.5节，自动换行)，因此缩进级别不变。例如：</p>

<div class="highlight"><pre><code class="java"><span class="nd">@Override</span>
<span class="nd">@Nullable</span>
<span class="kd">public</span> <span class="n">String</span> <span class="nf">getNameIfPresent</span><span class="o">()</span> <span class="o">{</span> <span class="o">...</span> <span class="o">}</span>
</code></pre></div>


<p><strong>例外</strong>：单个的注解可以和签名的第一行出现在同一行。例如：</p>

<div class="highlight"><pre><code class="java"><span class="nd">@Override</span> <span class="kd">public</span> <span class="kt">int</span> <span class="n">hashCode</span><span class="o">()</span> <span class="o">{</span> <span class="o">...</span> <span class="o">}</span>
</code></pre></div>


<p>应用于字段的注解紧随文档块出现，应用于字段的多个注解允许与字段出现在同一行。例如：</p>

<div class="highlight"><pre><code class="java"><span class="nd">@Partial</span> <span class="nd">@Mock</span> <span class="n">DataLoader</span> <span class="n">loader</span><span class="o">;</span>
</code></pre></div>


<p>参数和局部变量注解没有特定规则。</p>

<h4>4.8.6 注释</h4>

<h5>4.8.6.1 块注释风格</h5>

<p>块注释与其周围的代码在同一缩进级别。它们可以是<code>/* ... */</code>风格，也可以是<code>// ...</code>风格。对于多行的<code>/* ... */</code>注释，后续行必须从<code>*</code>开始，
并且与前一行的<code>*</code>对齐。以下示例注释都是OK的。</p>

<div class="highlight"><pre><code class="java"><span class="cm">/*</span>
<span class="cm"> * This is          // And so           /* Or you can</span>
<span class="cm"> * okay.            // is this.          * even do this. */</span>
 <span class="o">*/</span>
</code></pre></div>


<p>注释不要封闭在由星号或其它字符绘制的框架里。</p>

<blockquote><blockquote><p>Tip：在写多行注释时，如果你希望在必要时能重新换行(即注释像段落风格一样)，那么使用<code>/* ... */</code>。</p></blockquote></blockquote>

<h4>4.8.7 Modifiers</h4>

<p>类和成员的modifiers如果存在，则按Java语言规范中推荐的顺序出现。</p>

<div class="highlight"><pre><code class="java"><span class="kd">public</span> <span class="kd">protected</span> <span class="kd">private</span> <span class="kd">abstract</span> <span class="kd">static</span> <span class="kd">final</span> <span class="kd">transient</span> <span class="kd">volatile</span> <span class="kd">synchronized</span> <span class="kd">native</span> <span class="kd">strictfp</span>
</code></pre></div>


<h2><a id="Naming">命名约定</a></h2>

<h3>5.1 对所有标识符都通用的规则</h3>

<p>标识符只能使用ASCII字母和数字，因此每个有效的标识符名称都能匹配正则表达式<code>\w+</code>。</p>

<p>在Google其它编程语言风格中使用的特殊前缀或后缀，如<code>name_</code>, <code>mName</code>, <code>s_name</code>和<code>kName</code>，在Java编程风格中都不再使用。</p>

<h3>5.2 标识符类型的规则</h3>

<h4>5.2.1 包名</h4>

<p>包名全部小写，连续的单词只是简单地连接起来，不使用下划线。</p>

<h4>5.2.2 类名</h4>

<p>类名都以<code>UpperCamelCase</code>风格编写。</p>

<p>类名通常是名词或名词短语，接口名称有时可能是形容词或形容词短语。现在还没有特定的规则或行之有效的约定来命名注解类型。</p>

<p>测试类的命名以它要测试的类的名称开始，以<code>Test</code>结束。例如，<code>HashTest</code>或<code>HashIntegrationTest</code>。</p>

<h4>5.2.3 方法名</h4>

<p>方法名都以<code>lowerCamelCase</code>风格编写。</p>

<p>方法名通常是动词或动词短语。</p>

<p>下划线可能出现在JUnit测试方法名称中用以分隔名称的逻辑组件。一个典型的模式是：<code>test&lt;MethodUnderTest&gt;_&lt;state&gt;</code>，例如<code>testPop_emptyStack</code>。
并不存在唯一正确的方式来命名测试方法。</p>

<h4>5.2.4 常量名</h4>

<p>常量名命名模式为<code>CONSTANT_CASE</code>，全部字母大写，用下划线分隔单词。那，到底什么算是一个常量？</p>

<p>每个常量都是一个静态final字段，但不是所有静态final字段都是常量。在决定一个字段是否是一个常量时，
考虑它是否真的感觉像是一个常量。例如，如果任何一个该实例的观测状态是可变的，则它几乎肯定不会是一个常量。
只是永远不<code>打算</code>改变对象一般是不够的，它要真的一直不变才能将它示为常量。</p>

<div class="highlight"><pre><code class="java"><span class="c1">// Constants</span>
<span class="kd">static</span> <span class="kd">final</span> <span class="kt">int</span> <span class="n">NUMBER</span> <span class="o">=</span> <span class="mi">5</span><span class="o">;</span>
<span class="kd">static</span> <span class="kd">final</span> <span class="n">ImmutableList</span><span class="o">&lt;</span><span class="n">String</span><span class="o">&gt;</span> <span class="n">NAMES</span> <span class="o">=</span> <span class="n">ImmutableList</span><span class="o">.</span><span class="na">of</span><span class="o">(</span><span class="s">"Ed"</span><span class="o">,</span> <span class="s">"Ann"</span><span class="o">);</span>
<span class="kd">static</span> <span class="kd">final</span> <span class="n">Joiner</span> <span class="n">COMMA_JOINER</span> <span class="o">=</span> <span class="n">Joiner</span><span class="o">.</span><span class="na">on</span><span class="o">(</span><span class="sc">','</span><span class="o">);</span>  <span class="c1">// because Joiner is immutable</span>
<span class="kd">static</span> <span class="kd">final</span> <span class="n">SomeMutableType</span><span class="o">[]</span> <span class="n">EMPTY_ARRAY</span> <span class="o">=</span> <span class="o">{};</span>
<span class="kd">enum</span> <span class="n">SomeEnum</span> <span class="o">{</span> <span class="n">ENUM_CONSTANT</span> <span class="o">}</span>

<span class="c1">// Not constants</span>
<span class="kd">static</span> <span class="n">String</span> <span class="n">nonFinal</span> <span class="o">=</span> <span class="s">"non-final"</span><span class="o">;</span>
<span class="kd">final</span> <span class="n">String</span> <span class="n">nonStatic</span> <span class="o">=</span> <span class="s">"non-static"</span><span class="o">;</span>
<span class="kd">static</span> <span class="kd">final</span> <span class="n">Set</span><span class="o">&lt;</span><span class="n">String</span><span class="o">&gt;</span> <span class="n">mutableCollection</span> <span class="o">=</span> <span class="k">new</span> <span class="n">HashSet</span><span class="o">&lt;</span><span class="n">String</span><span class="o">&gt;();</span>
<span class="kd">static</span> <span class="kd">final</span> <span class="n">ImmutableSet</span><span class="o">&lt;</span><span class="n">SomeMutableType</span><span class="o">&gt;</span> <span class="n">mutableElements</span> <span class="o">=</span> <span class="n">ImmutableSet</span><span class="o">.</span><span class="na">of</span><span class="o">(</span><span class="n">mutable</span><span class="o">);</span>
<span class="kd">static</span> <span class="kd">final</span> <span class="n">Logger</span> <span class="n">logger</span> <span class="o">=</span> <span class="n">Logger</span><span class="o">.</span><span class="na">getLogger</span><span class="o">(</span><span class="n">MyClass</span><span class="o">.</span><span class="na">getName</span><span class="o">());</span>
<span class="kd">static</span> <span class="kd">final</span> <span class="n">String</span><span class="o">[]</span> <span class="n">nonEmptyArray</span> <span class="o">=</span> <span class="o">{</span><span class="s">"these"</span><span class="o">,</span> <span class="s">"can"</span><span class="o">,</span> <span class="s">"change"</span><span class="o">};</span>
</code></pre></div>


<p>这些名字通常是名词或名词短语。</p>

<h4>5.2.5 非常量字段名</h4>

<p>非常量字段名以<code>lowerCamelCase</code>风格编写。</p>

<p>这些名字通常是名词或名词短语。</p>

<h4>5.2.6 参数名</h4>

<p>参数名以<code>lowerCamelCase</code>风格编写。</p>

<p>参数应该避免用单个字符命名。</p>

<h4>5.2.7 局部变量名</h4>

<p>局部变量名以<code>lowerCamelCase</code>风格编写，比起其它类型的名称，局部变量名可以有更为宽松的缩写。</p>

<p>虽然缩写更宽松，但还是要避免用单字符进行命名，除了临时变量和循环变量。</p>

<p>即使局部变量是final和不可改变的，也不应该把它示为常量，自然也不能用常量的规则去命名它。</p>

<h4>5.2.8 类型变量名</h4>

<p>类型变量可用以下两种风格之一进行命名：</p>

<ul>
<li>单个的大写字母，后面可以跟一个数字(如：E, T, X, T2)。</li>
<li>以类命名方式(5.2.2节)，后面加个大写的T(如：RequestT, FooBarT)。</li>
</ul>


<h3>5.3 驼峰式命名法(CamelCase)</h3>

<p><a href="http://zh.wikipedia.org/wiki/%E9%A7%9D%E5%B3%B0%E5%BC%8F%E5%A4%A7%E5%B0%8F%E5%AF%AB">驼峰式命名法</a>分大驼峰式命名法(<code>UpperCamelCase</code>)和小驼峰式命名法(<code>lowerCamelCase</code>)。
有时，我们有不只一种合理的方式将一个英语词组转换成驼峰形式，如缩略语或不寻常的结构(例如"IPv6"或"iOS")。Google指定了以下的转换方案。</p>

<p>名字从<code>散文形式</code>(prose form)开始:</p>

<ol>
<li>把短语转换为纯ASCII码，并且移除任何单引号。例如："Müller’s algorithm"将变成"Muellers algorithm"。</li>
<li>把这个结果切分成单词，在空格或其它标点符号(通常是连字符)处分割开。

<ul>
<li>推荐：如果某个单词已经有了常用的驼峰表示形式，按它的组成将它分割开(如"AdWords"将分割成"ad words")。
需要注意的是"iOS"并不是一个真正的驼峰表示形式，因此该推荐对它并不适用。</li>
</ul>
</li>
<li>现在将所有字母都小写(包括缩写)，然后将单词的第一个字母大写：

<ul>
<li>每个单词的第一个字母都大写，来得到大驼峰式命名。</li>
<li>除了第一个单词，每个单词的第一个字母都大写，来得到小驼峰式命名。</li>
</ul>
</li>
<li>最后将所有的单词连接起来得到一个标识符。</li>
</ol>


<p>示例：</p>

<pre><code>Prose form                Correct               Incorrect
------------------------------------------------------------------
"XML HTTP request"        XmlHttpRequest        XMLHTTPRequest
"new customer ID"         newCustomerId         newCustomerID
"inner stopwatch"         innerStopwatch        innerStopWatch
"supports IPv6 on iOS?"   supportsIpv6OnIos     supportsIPv6OnIOS
"YouTube importer"        YouTubeImporter
                          YoutubeImporter*
</code></pre>

<p>加星号处表示可以，但不推荐。</p>

<blockquote><blockquote><p>Note：在英语中，某些带有连字符的单词形式不唯一。例如："nonempty"和"non-empty"都是正确的，因此方法名<code>checkNonempty</code>和<code>checkNonEmpty</code>也都是正确的。</p></blockquote></blockquote>

<h2><a id="Practice">编程实践</a></h2>

<h3>6.1 @Override：能用则用</h3>

<p>只要是合法的，就把<code>@Override</code>注解给用上。</p>

<h3>6.2 捕获的异常：不能忽视</h3>

<p>除了下面的例子，对捕获的异常不做响应是极少正确的。(典型的响应方式是打印日志，或者如果它被认为是不可能的，则把它当作一个<code>AssertionError</code>重新抛出。)</p>

<p>如果它确实是不需要在catch块中做任何响应，需要做注释加以说明(如下面的例子)。</p>

<div class="highlight"><pre><code class="java"><span class="k">try</span> <span class="o">{</span>
  <span class="kt">int</span> <span class="n">i</span> <span class="o">=</span> <span class="n">Integer</span><span class="o">.</span><span class="na">parseInt</span><span class="o">(</span><span class="n">response</span><span class="o">);</span>
  <span class="k">return</span> <span class="nf">handleNumericResponse</span><span class="o">(</span><span class="n">i</span><span class="o">);</span>
<span class="o">}</span> <span class="k">catch</span> <span class="o">(</span><span class="n">NumberFormatException</span> <span class="n">ok</span><span class="o">)</span> <span class="o">{</span>
  <span class="c1">// it's not numeric; that's fine, just continue</span>
<span class="o">}</span>
<span class="k">return</span> <span class="nf">handleTextResponse</span><span class="o">(</span><span class="n">response</span><span class="o">);</span>
</code></pre></div>


<p><strong>例外</strong>：在测试中，如果一个捕获的异常被命名为<code>expected</code>，则它可以被不加注释地忽略。下面是一种非常常见的情形，用以确保所测试的方法会抛出一个期望中的异常，
因此在这里就没有必要加注释。</p>

<div class="highlight"><pre><code class="java"><span class="k">try</span> <span class="o">{</span>
  <span class="n">emptyStack</span><span class="o">.</span><span class="na">pop</span><span class="o">();</span>
  <span class="n">fail</span><span class="o">();</span>
<span class="o">}</span> <span class="k">catch</span> <span class="o">(</span><span class="n">NoSuchElementException</span> <span class="n">expected</span><span class="o">)</span> <span class="o">{</span>
<span class="o">}</span>
</code></pre></div>


<h3>6.3 静态成员：使用类进行调用</h3>

<p>使用类名调用静态的类成员，而不是具体某个对象或表达式。</p>

<div class="highlight"><pre><code class="java"><span class="n">Foo</span> <span class="n">aFoo</span> <span class="o">=</span> <span class="o">...;</span>
<span class="n">Foo</span><span class="o">.</span><span class="na">aStaticMethod</span><span class="o">();</span> <span class="c1">// good</span>
<span class="n">aFoo</span><span class="o">.</span><span class="na">aStaticMethod</span><span class="o">();</span> <span class="c1">// bad</span>
<span class="n">somethingThatYieldsAFoo</span><span class="o">().</span><span class="na">aStaticMethod</span><span class="o">();</span> <span class="c1">// very bad</span>
</code></pre></div>


<h3>6.4 Finalizers: 禁用</h3>

<p>极少会去重载<code>Object.finalize</code>。</p>

<blockquote><blockquote><p>Tip：不要使用finalize。如果你非要使用它，请先仔细阅读和理解<a href="http://books.google.com/books?isbn=8131726592">Effective Java</a>
第7条款：“Avoid Finalizers”，然后不要使用它。</p></blockquote></blockquote>

<h2><a id="Javadoc">Javadoc</a></h2>

<h3>7.1 格式</h3>

<h4>7.1.1 一般形式</h4>

<p>Javadoc块的基本格式如下所示：</p>

<div class="highlight"><pre><code class="java"><span class="cm">/**</span>
<span class="cm"> * Multiple lines of Javadoc text are written here,</span>
<span class="cm"> * wrapped normally...</span>
<span class="cm"> */</span>
<span class="kd">public</span> <span class="kt">int</span> <span class="nf">method</span><span class="o">(</span><span class="n">String</span> <span class="n">p1</span><span class="o">)</span> <span class="o">{</span> <span class="o">...</span> <span class="o">}</span>
</code></pre></div>


<p>或者是以下单行形式：</p>

<div class="highlight"><pre><code class="java"><span class="cm">/** An especially short bit of Javadoc. */</span>
</code></pre></div>


<p>基本格式总是OK的。当整个Javadoc块能容纳于一行时(且没有Javadoc标记@XXX)，可以使用单行形式。</p>

<h4>7.1.2 段落</h4>

<p>空行(即，只包含最左侧星号的行)会出现在段落之间和Javadoc标记(@XXX)之前(如果有的话)。
除了第一个段落，每个段落第一个单词前都有标签<code>&lt;p&gt;</code>，并且它和第一个单词间没有空格。</p>

<h4>7.1.3 Javadoc标记</h4>

<p>标准的Javadoc标记按以下顺序出现：<code>@param</code>, <code>@return</code>, <code>@throws</code>, <code>@deprecated</code>, 前面这4种标记如果出现，描述都不能为空。
当描述无法在一行中容纳，连续行需要至少再缩进4个空格。</p>

<h3>7.2 摘要片段</h3>

<p>每个类或成员的Javadoc以一个简短的摘要片段开始。这个片段是非常重要的，在某些情况下，它是唯一出现的文本，比如在类和方法索引中。</p>

<p>这只是一个小片段，可以是一个名词短语或动词短语，但不是一个完整的句子。它不会以<code>A {@code Foo} is a...</code>或<code>This method returns...</code>开头,
它也不会是一个完整的祈使句，如<code>Save the record...</code>。然而，由于开头大写及被加了标点，它看起来就像是个完整的句子。</p>

<blockquote><blockquote><p>Tip：一个常见的错误是把简单的Javadoc写成<code>/** @return the customer ID */</code>，这是不正确的。它应该写成<code>/** Returns the customer ID. */</code>。</p></blockquote></blockquote>

<h3>7.3 哪里需要使用Javadoc</h3>

<p>至少在每个public类及它的每个public和protected成员处使用Javadoc，以下是一些例外：</p>

<h4>7.3.1 例外：不言自明的方法</h4>

<p>对于简单明显的方法如<code>getFoo</code>，Javadoc是可选的(即，是可以不写的)。这种情况下除了写“Returns the foo”，确实也没有什么值得写了。</p>

<p>单元测试类中的测试方法可能是不言自明的最常见例子了，我们通常可以从这些方法的描述性命名中知道它是干什么的，因此不需要额外的文档说明。</p>

<blockquote><blockquote><p>Tip：如果有一些相关信息是需要读者了解的，那么以上的例外不应作为忽视这些信息的理由。例如，对于方法名<code>getCanonicalName</code>，
就不应该忽视文档说明，因为读者很可能不知道词语<code>canonical name</code>指的是什么。</p></blockquote></blockquote>

<h4>7.3.2 例外：重载</h4>

<p>如果一个方法重载了超类中的方法，那么Javadoc并非必需的。</p>

<h4>7.3.3 可选的Javadoc</h4>

<p>对于包外不可见的类和方法，如有需要，也是要使用Javadoc的。如果一个注释是用来定义一个类，方法，字段的整体目的或行为，
那么这个注释应该写成Javadoc，这样更统一更友好。</p>

<h2><a id="End">后记</a></h2>

<p>本文档翻译自<a href="http://google-styleguide.googlecode.com/svn/trunk/javaguide.html">Google Java Style</a>，
译者<a href="http://weibo.com/hawstein">@Hawstein</a>。</p>

</div>

<br>
<!-- JiaThis Button BEGIN -->
<div class="jiathis_style">
<a title="分享到新浪微博" class="jiathis_button_tsina"><span class="jiathis_txt jtico jtico_tsina"></span></a>
<a title="分享到腾讯微博" class="jiathis_button_tqq"><span class="jiathis_txt jtico jtico_tqq"></span></a>
<a title="分享到搜狐微博" class="jiathis_button_tsohu"><span class="jiathis_txt jtico jtico_tsohu"></span></a>
<a title="分享到网易微博" class="jiathis_button_t163"><span class="jiathis_txt jtico jtico_t163"></span></a>
<a title="分享到豆瓣" class="jiathis_button_douban"><span class="jiathis_txt jtico jtico_douban"></span></a>
<a title="分享到人人网" class="jiathis_button_renren"><span class="jiathis_txt jtico jtico_renren"></span></a>
<a class="jiathis_button_zhuaxia"></a>
<a title="分享到饭否" class="jiathis_button_fanfou"><span class="jiathis_txt jtico jtico_fanfou"></span></a>
<a title="分享到Twitter" class="jiathis_button_twitter"><span class="jiathis_txt jtico jtico_twitter"></span></a>
<a title="分享到Facebook" class="jiathis_button_fb"><span class="jiathis_txt jtico jtico_fb"></span></a>
<a title="分享到Gmail邮箱" class="jiathis_button_gmail"><span class="jiathis_txt jtico jtico_gmail"></span></a>
<a title="分享到LinkedIn" class="jiathis_button_linkedin"><span class="jiathis_txt jtico jtico_linkedin"></span></a>
<a title="分享到FriendFeed" class="jiathis_button_friendfeed"><span class="jiathis_txt jtico jtico_friendfeed"></span></a>
<a title="分享到Digg" class="jiathis_button_digg"><span class="jiathis_txt jtico jtico_digg"></span></a>
<a href="http://www.jiathis.com/share?uid=1939314" class="jiathis jiathis_txt jiathis_separator jtico jtico_jiathis" target="_blank"></a>
<a class="jiathis_counter_style"><span title="累计分享8次" id="jiathis_counter_48" class="jiathis_button_expanded jiathis_counter jiathis_bubble_style">8</span></a>
</div>
<script type="text/javascript">
var jiathis_config={
	data_track_clickback:true,
	summary:" // By @Hawstein ",
	hideMore:false
}
</script>

<script type="text/javascript" src="Google%20Java%E7%BC%96%E7%A8%8B%E9%A3%8E%E6%A0%BC%E6%8C%87%E5%8D%97_files/jia.js" charset="utf-8"></script>
<!-- JiaThis Button END -->
<br>

<div id="related">
  <h2>Random Posts</h2>
  <ul class="posts">
    
      <li><span>01 Jul 2014</span> » <a href="http://hawstein.com/posts/make-thiner-tspl.html">把《The Swift Programming Language》读薄</a></li>
    
      <li><span>06 Mar 2014</span> » <a href="http://hawstein.com/posts/make-thiner-make-friend-with-time.html">把《把时间当作朋友》读薄</a></li>
    
      <li><span>11 Aug 2013</span> » <a href="http://hawstein.com/posts/make-thiner-programming-pearls.html">把《编程珠玑》读薄</a></li>
    
      <li><span>23 Jul 2013</span> » <a href="http://hawstein.com/posts/lru-cache-impl.html">如何用C++实现一个LRU Cache</a></li>
    
      <li><span>18 Jul 2013</span> » <a href="http://hawstein.com/posts/ibar-begin.html">微信公众平台：程序员的面试吧</a></li>
    
  </ul>
</div>
<div id="disqus_thread"><iframe verticalscrolling="no" horizontalscrolling="no" src="Google%20Java%E7%BC%96%E7%A8%8B%E9%A3%8E%E6%A0%BC%E6%8C%87%E5%8D%97_files/a.html" style="width: 100% ! important; border: medium none ! important; overflow: hidden ! important; height: 898px ! important;" title="Disqus" tabindex="0" scrolling="no" allowtransparency="true" data-disqus-uid="2" id="dsq-2" frameborder="0" width="100%"></iframe></div>
<script type="text/javascript">
    
    var disqus_shortname = 'hawstein';
    (function() {
        var dsq = document.createElement('script'); dsq.type = 'text/javascript'; dsq.async = true;
        dsq.src = 'http://' + disqus_shortname + '.disqus.com/embed.js';
        (document.getElementsByTagName('head')[0] || document.getElementsByTagName('body')[0]).appendChild(dsq);
    })();
</script>
<noscript>Please enable JavaScript to view the <a href="http://disqus.com/?ref_noscript">comments powered by Disqus.</a></noscript>


	  <div id="footer">
  Powered by <a href="https://github.com/mojombo/jekyll">Jekyll</a> and <a href="http://twitter.github.com/bootstrap/">Bootstrap</a>.  Last updated at 2014-07-01 06:45:25 -0700.
</div>

	</div>
	<script src="Google%20Java%E7%BC%96%E7%A8%8B%E9%A3%8E%E6%A0%BC%E6%8C%87%E5%8D%97_files/jquery.js"></script>
	<script src="Google%20Java%E7%BC%96%E7%A8%8B%E9%A3%8E%E6%A0%BC%E6%8C%87%E5%8D%97_files/app.js"></script>
	<script type="text/javascript">


  var _gaq = _gaq || [];
  _gaq.push(['_setAccount', 'UA-37837952-1']);
  _gaq.push(['_trackPageview']);


  (function() {
    var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
    ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
    var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
  })();


</script>

      

</body></html>